import pandas as pd
import time

from pandas.core.interchange import column

from h3yun.service import site_data_service

# a 流向表单
# b 个人报销
# c 市场费用申请
# d 物品领用申请
# 先把b个人报销表
file_prefix_path = 'C:\\Users\\12630\\Desktop\\数据表单'
file_a_path = f"{file_prefix_path}\\流向表单.xlsx"
file_b_path = f"{file_prefix_path}\\个人报销.xlsx"
file_c_path = f"{file_prefix_path}\\市场费用申请.xlsx"
file_d_path = f"{file_prefix_path}\\物品领用申请.xlsx"

file_statistic_name_path = 'C:\\Users\\12630\\Desktop\\数据表单\\流向与报销表单合并.xlsx'

statistic_person_name = []


def get_statistic_person_name():
    df = pd.read_excel(file_statistic_name_path, sheet_name=0)
    global statistic_person_name
    statistic_person_name = df['姓名'].to_numpy()


def get_statistic_person_dict():
    df = pd.read_excel(file_statistic_name_path, sheet_name=0)
    statistic_person_dict = {}
    for i in range(len(df['姓名'])):
        statistic_person_dict[df['姓名'][i]] = df['所属部门'][i]
    return statistic_person_dict


def clean_a():
    df = pd.read_excel(file_a_path)
    # df = df[df['流向明细.专员'].isin(statistic_person_name)]
    data = {
        '年月': df['流向明细.年份'].astype(str) + '-' + df['流向明细.月份'].astype(str),
        '流向明细.区域': df['流向明细.区域'],
        '流向明细.专员': df['流向明细.专员'],
        '站点': df['流向明细.医院名称'],
        '产品一级名称': df['流向明细.一级分类'],
        '产品二级名称': df['流向明细.二级分类'],
        '流向明细.营业额（含税）': df['流向明细.营业额（含税）'],
        '流向明细.配送费': df['流向明细.配送费'],
        '流向明细.SPD费': df['流向明细.SPD费'],
        '流向明细.MS费': df['流向明细.MS费'],
    }
    df_cleaned = pd.DataFrame(data)
    df_cleaned['年月'] = df_cleaned['年月'].str.extract('(\d{4})年-(\d{1,2})月').astype(str).apply(
        lambda x: '-'.join([x[0], x[1].zfill(2)]), axis=1)
    grouped_array = ['年月', '流向明细.区域', '流向明细.专员', '站点', '产品一级名称', '产品二级名称']
    grouped_df = df_cleaned.groupby(grouped_array).agg({
        '流向明细.营业额（含税）': 'sum',
        '流向明细.配送费': 'sum',
        '流向明细.SPD费': 'sum',
        '流向明细.MS费': 'sum',
    }).reset_index()

    grouped_df.to_excel('清洗过后的a表格.xlsx', index=False)


def clean_b():
    df = pd.read_excel(file_b_path)
    df = fill_blank(df, '报销人')
    df = fill_blank(df, '报销类型')
    data = {
        '报销人': df['报销人'],
        '报销类型': df['报销类型'],
        '日常报销单据.费用使用日期': df['日常报销单据.费用使用日期'],
        '日常报销单据.站点': df['日常报销单据.站点'],
        '日常报销单据.产品一级名称': df['日常报销单据.产品一级名称'],
        '日常报销单据.产品二级名称': df['日常报销单据.产品二级名称'],
        '日常报销单据.报销金额（元）': df['日常报销单据.报销金额（元）'],
        '差旅报销单据.费用使用日期': df['差旅报销单据.费用使用日期'],
        '差旅报销单据.站点': df['差旅报销单据.站点'],
        '差旅报销单据.产品一级名称': df['差旅报销单据.产品一级名称'],
        '差旅报销单据.产品二级名称': df['差旅报销单据.产品二级名称'],
        '差旅报销单据.报销金额（元）': df['差旅报销单据.报销金额（元）'],
    }
    df = pd.DataFrame(data)
    df = handle_b(df)
    df.to_excel('填充过后的b表格.xlsx', index=False)

    # 去掉不需要统计的报销人的行
    df = df[df['报销人'].isin(statistic_person_name)]
    # 年月日 去掉 日 便于合并
    df['报销单据.费用使用日期'] = pd.to_datetime(df['报销单据.费用使用日期']).dt.to_period('M')
    # 合并相同年月
    grouped_df = df.groupby(['报销人', '报销站点', '报销单据.产品一级名称', '报销单据.产品二级名称', '报销单据.费用使用日期'],
                            dropna=False).agg({
        '报销金额（元）': 'sum',
    }).reset_index()
    grouped_df.to_excel('清洗过后的b表格.xlsx', index=False)


def clean_c():
    df = pd.read_excel(file_c_path)
    # 去掉不需要统计的申请人的行
    df = df[df['申请人'].isin(statistic_person_name)]
    data = {
        '申请人': df['申请人'],
        '所属部门': df['所属部门'],
        '费用明细.费用使用日期': df['费用明细.费用使用日期'],
        '费用明细.站点': df['费用明细.站点'],
        '费用明细.产品一级类别': df['费用明细.产品一级类别'],
        '费用明细.产品二级类别': df['费用明细.产品二级类别'],
        '费用明细.税前金额（元）': df['费用明细.税前金额（元）']
    }
    df = pd.DataFrame(data)
    df = fill_blank(df, '申请人')
    # 年月日 去掉日
    df['费用明细.费用使用日期'] = pd.to_datetime(df['费用明细.费用使用日期']).dt.to_period('M')
    # 合并相同的年月
    grouped_df = df.groupby(
        ['申请人', '费用明细.站点', '费用明细.产品一级类别', '费用明细.产品二级类别', '费用明细.费用使用日期'],
        dropna=False).agg({
        '费用明细.税前金额（元）': 'sum',
    }).reset_index()

    grouped_df.to_excel('清洗过后的c表格.xlsx', index=False)


def clean_d():
    df = pd.read_excel(file_d_path)
   # df = fill_blank(df, '所属部门')
    df = fill_blank(df, '领用日期')
    df = fill_blank(df, '提交方式')
    # df = fill_blank(df, '创建人')
    # df = fill_blank(df, '实际领用人')
    # df = fill_blank(df, '实际领用人部门')
    df = fill_blank(df, '流程状态')
    # 先填充
    submit_types = df['提交方式'].fillna('').to_numpy()
    creators = df['创建人'].fillna('').to_numpy()
    actual_creators = df['实际领用人'].fillna('').to_numpy()
    i = 0
    while True:
        if submit_types[i] == '自己提交':
            creator = creators[i]
            while True:
                i = i + 1
                if i >= len(submit_types):
                    break
                if submit_types[i] == '自己提交' and len(creators[i]) == 0:
                    creators[i] = creator
                else:
                    break
        elif submit_types[i] == '代提交':
            actual_creator = actual_creators[i]
            while True:
                i = i + 1
                if i >= len(submit_types):
                    break
                if submit_types[i] == '代提交' and len(actual_creators[i]) == 0:
                    actual_creators[i] = actual_creator
                else:
                    break
        if i >= len(submit_types):
            break

    df['提交方式'] = submit_types
    df['创建人'] = creators
    df['实际领用人'] = actual_creators
    df.to_excel("填充之后的d表格.xlsx", index=False)

    # 1. 把所有流程状态是草稿的数据去掉
    condition = df['流程状态'] != '草稿'
    df = df[condition]

    # 2.先取出所有待提交的数据
    condition = df['提交方式'] == '自己提交'
    df1 = df[condition]
    data = {
        '领用日期': df['领用日期'],
        '领用人': df['创建人'],
        '领用明细.一级分类': df['领用明细.一级分类'],
        '领用明细.产品一级名称': df['领用明细.产品一级名称'],
        '领用明细.产品二级名称': df['领用明细.产品二级名称'],
        '领用明细.归属站点': df['领用明细.归属站点'],
        '领用明细.小计': df['领用明细.小计']
    }
    df1 = pd.DataFrame(data)
    df1.to_excel("自己提交df1.xlsx", index=False)

    # 3.在取出所有代提的数据
    condition = df['提交方式'] == '代提交'
    df2 = df[condition]
    data = {
        '领用日期': df['领用日期'],
        '领用人': df['实际领用人'],
        '领用明细.一级分类': df['领用明细.一级分类'],
        '领用明细.产品一级名称': df['领用明细.产品一级名称'],
        '领用明细.产品二级名称': df['领用明细.产品二级名称'],
        '领用明细.归属站点': df['领用明细.归属站点'],
        '领用明细.小计': df['领用明细.小计']
    }
    df2 = pd.DataFrame(data)
    df2.to_excel("代提交df2.xlsx", index=False)

    # 4. 把 df1 和 df2合并在一起 然后在取出 “领用明细.一级分类” 只是 “礼品及酒水” 的数据
    df3 = pd.concat([df1, df2], ignore_index=True)
    condition = df3['领用明细.一级分类'] == '礼品及酒水'
    df3 = df3[condition]

    # 5. 去掉不是需要统计的人员的名单的数据
    df3 = df3[df3['领用人'].isin(statistic_person_name)]

    # 6. 领用日期 年月日 规定到 年月
    df3['领用日期'] = pd.to_datetime(df3['领用日期']).dt.to_period('M')

    # 7. 把 领用人 站点 产品一级名称  产品二级名称 相同年月合并起来 （有问题）
    grouped_df = df3.groupby(
        ['领用人', '领用明细.归属站点', '领用明细.产品一级名称', '领用明细.产品二级名称', '领用日期'],
        dropna=False).agg({'领用明细.小计': 'sum'}).reset_index()
    grouped_df.to_excel('清洗过后的d表格.xlsx', index=False)


# 这个方法主要是为了把 报销表当中的 差旅报销和日常报销合并到一起
def handle_b(df):
    data = {
        '报销人': df['报销人'],
        '报销类型': df['报销类型'],
        '报销单据.费用使用日期': df['日常报销单据.费用使用日期'],
        '报销站点': df['日常报销单据.站点'],
        '报销单据.产品一级名称': df['日常报销单据.产品一级名称'],
        '报销单据.产品二级名称': df['日常报销单据.产品二级名称'],
        '报销金额（元）': df['日常报销单据.报销金额（元）'],
    }
    df1 = pd.DataFrame(data)
    condition = df1['报销类型'] == '日常报销'
    df1 = df1[condition]
    data = {
        '报销人': df['报销人'],
        '报销类型': df['报销类型'],
        '报销单据.费用使用日期': df['差旅报销单据.费用使用日期'],
        '报销站点': df['差旅报销单据.站点'],
        '报销单据.产品一级名称': df['差旅报销单据.产品一级名称'],
        '报销单据.产品二级名称': df['差旅报销单据.产品二级名称'],
        '报销金额（元）': df['差旅报销单据.报销金额（元）'],
    }
    df2 = pd.DataFrame(data)
    condition = df2['报销类型'] == '差旅费报销'
    df2 = df2[condition]
    result_df = pd.concat([df1, df2], ignore_index=True)
    return result_df


# 把子表空表的字段填上
def fill_blank(df, name):
    temp = df[name].fillna('').to_numpy()
    for i in range(len(temp)):
        if len(temp[i]) == 0 and i != 0:
            temp[i] = temp[i - 1]
    df[name] = temp
    return df


def merge_a_and_b_and_c_and_d():
    # 记录函数执行前的时间戳
    start_time = time.time()
    clean_a()
    clean_b()
    clean_c()
    clean_d()
    # 读取a表和b表
    df_a = pd.read_excel('清洗过后的a表格.xlsx')
    df_b = pd.read_excel('清洗过后的b表格.xlsx')
    df_c = pd.read_excel('清洗过后的c表格.xlsx')
    df_d = pd.read_excel("清洗过后的d表格.xlsx")

    # 合并表格，根据多列进行合并
    # 合并 a b
    merged_ab = pd.merge(df_a, df_b,
                         left_on=['年月', '流向明细.专员', '站点', '产品一级名称', '产品二级名称'],
                         right_on=['报销单据.费用使用日期', '报销人', '报销站点', '报销单据.产品一级名称', '报销单据.产品二级名称'],
                         how='outer', indicator=True)
    merged_ab.to_excel('a表和b表的合并结果.xlsx', index=False)

    # 根据指示器列过滤行
    # condition = merged_ab['_merge'] == 'both'  # 'both'表示匹配
    # # result_df 去除了_merge结果的那一列
    # result_ab = merged_ab[condition].drop('_merge', axis=1)

    column_to_delete = '_merge'  # 替换为你要删除的列名
    merged_ab = merged_ab.drop(columns=[column_to_delete])

    # print(merged_ab.dtypes)
    # print(df_c.dtypes)
    # 如果某一列为空 会变成float64 没办法合并
    df_c['费用明细.产品一级类别'] = df_c['费用明细.产品二级类别'].astype(object)
    df_c['费用明细.产品二级类别'] = df_c['费用明细.产品二级类别'].astype(object)
    # 合并 ab 和 c
    merged_abc = pd.merge(merged_ab, df_c,
                          left_on=['年月', '流向明细.专员', '站点', '产品一级名称', '产品二级名称'],
                          right_on=['费用明细.费用使用日期', '申请人', '费用明细.站点', '费用明细.产品一级类别',
                                    '费用明细.产品二级类别'],
                          how='outer', indicator=True
                          )
    merged_abc.to_excel('a表和b表和c表的合并结果.xlsx', index=False)
    merged_abc = merged_abc.drop(columns=[column_to_delete])

    # 合并 abc 和 d
    merged_abcd = pd.merge(merged_abc, df_d,
                          left_on=['年月', '流向明细.专员', '站点', '产品一级名称', '产品二级名称'],
                          right_on=['领用日期', '领用人', '领用明细.归属站点', '领用明细.产品一级名称', '领用明细.产品二级名称'],
                          how='outer', indicator=True
                          )
    merged_abcd = merged_abcd.drop(columns=[column_to_delete])
    merged_abcd.to_excel('a表和b表和和c表和d表的合并结果.xlsx', index=False)

    # 合并两列数据
    handle_column_merge_and_mate_site_code(merged_abcd)

    end_time = time.time()
    execution_time = end_time - start_time

    print(f"完成时间: {execution_time} 秒")


def handle_column_merge_and_mate_site_code(df):
    df['年月'] = df['年月'].fillna(df['报销单据.费用使用日期']).fillna(df['费用明细.费用使用日期']).fillna(df['领用日期'])
    df.drop(['报销单据.费用使用日期', '领用日期', '费用明细.费用使用日期'], axis=1, inplace=True)

    df['姓名'] = df['流向明细.专员'].fillna(df['报销人']).fillna(df['申请人']).fillna(df['领用人'])
    df.drop(['流向明细.专员', '报销人', '申请人', '领用人'], axis=1, inplace=True)

    df['站点'] = df['站点'].fillna(df['报销站点']).fillna(df['费用明细.站点']).fillna(df['领用明细.归属站点'])
    df.drop(['报销站点', '费用明细.站点', '领用明细.归属站点'], axis=1, inplace=True)

    df['产品一级名称'] = df['产品一级名称'].fillna(df['报销单据.产品一级名称']).fillna(df['费用明细.产品一级类别']).fillna(df['领用明细.产品一级名称'])
    df.drop(['报销单据.产品一级名称', '费用明细.产品一级类别', '领用明细.产品一级名称'], axis=1, inplace=True)

    df['产品二级名称'] = df['产品二级名称'].fillna(df['报销单据.产品二级名称']).fillna(df['费用明细.产品二级类别']).fillna(df['领用明细.产品二级名称'])
    df.drop(['报销单据.产品二级名称', '费用明细.产品二级类别', '领用明细.产品二级名称'], axis=1, inplace=True)

    # 匹配站点
    site_list_code = []
    site_dict = get_site_dict()
    for site in df['站点']:
        if site in site_dict:
            site_list_code.append(site_dict[site])
        else:
            site_list_code.append('')

   # 取出对应的列
    data = {
        '年月': df['年月'],
        '年月2': df['年月'],
        '区域': df['流向明细.区域'],
        '姓名': df['姓名'],
        # 站点编码这里初始化有问题
        '站点编码': site_list_code,
        '站点': df['站点'],
        '产品一级名称': df['产品一级名称'],
        '产品二级名称': df['产品二级名称'],
        '流向.收入': df['流向明细.营业额（含税）'],
        '流向.配送费': df['流向明细.配送费'],
        '流向.SPD费': df['流向明细.SPD费'],
        '流向.MS费': df['流向明细.MS费'],
        '报销金额': df['报销金额（元）'],
        '市场费用金额': df['费用明细.税前金额（元）'],
        '礼品及酒水领用金额': df['领用明细.小计'],
    }
    df = pd.DataFrame(data)

    # 把区域为空的也补上
    site_list = df['区域'].fillna('').to_numpy()
    name_list = df['姓名'].fillna('').to_numpy()
    statistic_person_dict = get_statistic_person_dict()
    for i in range(len(site_list)):
        if len(site_list[i]) == 0:
            if name_list[i] in statistic_person_dict:
                site_list[i] = statistic_person_dict[name_list[i]]
    df['区域'] = site_list
    df['姓名'] = name_list
    df.to_excel("没有按年月排序的列合并结果.xlsx", index=False)

    # 排序 把相同的年月都排到一起
    df = df.sort_values(by='年月', ascending=False)

    df.to_excel("没有清除相同年月的列合并结果.xlsx", index=False)

    # 清除重复的年月
    df.loc[df.duplicated(subset='年月'), '年月'] = ''

    # 把年月2 换成 年月
    df = df.rename(columns={'年月2': '年月'})

    df.to_excel("投入产出分析.xlsx", index=False)


def get_site_dict():
    site_dict = {}
    # 先查站点信息基本表
    site_list1 = site_data_service.find_site_info_data()
    # 在查站点信息变更表
    site_list2 = site_data_service.find_change_site_info_data()
    site_list = site_list1 + site_list2
    for site in site_list:
        site_name = site['F0000011']
        site_code = site['F0000026']
        # if site_name in site_dict:
        #     print(site_name)
        # 广东医科大学附属东莞第一医院 站点里面出现了两次 这个医院名称弄出来的字典 有重复了
        site_dict[site_name] = site_code
        # site_dict[site_code] = site_name

    return site_dict


if __name__ == '__main__':
    get_statistic_person_name()
    merge_a_and_b_and_c_and_d()




# def clean_AB():
#     # 记录函数执行前的时间戳
#     start_time = time.time()
#     file_AB_path = "C:\\Users\\12630\\Desktop\\数据表单\\a表和b表合并的结果.xlsx"
#     df_AB = pd.read_excel(file_AB_path)
#     data = {
#         '年月':df_AB['年份'].str.extract('(\d+)') + '-' + df_AB['月份'].str.extract('(\d+)'),
#         '流向明细.区域': df_AB['流向明细.区域'],
#         '流向明细.专员':df_AB['流向明细.专员'],
#         '流向明细.医院名称':df_AB['流向明细.医院名称'],
#         '流向明细.一级分类':df_AB['流向明细.一级分类'],
#         '流向明细.二级分类':df_AB['流向明细.二级分类'],
#         '流向明细.营业额（含税）':df_AB['流向明细.营业额（含税）'],
#         '流向明细.配送费':df_AB['流向明细.配送费'],
#         '流向明细.SPD费':df_AB['流向明细.SPD费'],
#         '流向明细.MS费':df_AB['流向明细.MS费'],
#         '日常报销单据.报销金额（元）':df_AB['日常报销单据.报销金额（元）'],
#         '日常报销单据.费用使用日期':df_AB['日常报销单据.费用使用日期'],
#         '日常报销单据.站点':df_AB['日常报销单据.站点'],
#         '日常报销单据.产品一级名称':df_AB['日常报销单据.产品一级名称'],
#         '日常报销单据.产品二级名称':df_AB['日常报销单据.产品二级名称'],
#         '学术会议报销单据.实际报销金额(元）':df_AB['学术会议报销单据.实际报销金额(元）'],
#         '学术会议报销单据.费用使用日期':df_AB['学术会议报销单据.费用使用日期'],
#         '学术会议报销单据.站点':df_AB['学术会议报销单据.站点'],
#         '学术会议报销单据.产品一级名称':df_AB['学术会议报销单据.产品一级名称'],
#         '学术会议报销单据.产品二级名称':df_AB['学术会议报销单据.产品二级名称'],
#         '差旅报销单据.报销金额（元）':df_AB['差旅报销单据.报销金额（元）'],
#         '差旅报销单据.费用使用日期':df_AB['差旅报销单据.费用使用日期'],
#         '差旅报销单据.站点':df_AB['差旅报销单据.站点'],
#         '差旅报销单据.产品一级名称':df_AB['差旅报销单据.产品一级名称'],
#         '差旅报销单据.产品二级名称':df_AB['差旅报销单据.产品二级名称'],
#     }
#     df_AB_result = pd.DataFrame(data)
#     df_AB_result.to_excel()
#     # 记录函数执行后的时间戳
#     end_time = time.time()
#     # 计算函数执行时间
#     execution_time = end_time - start_time
#     print(f"a表和b表的合并时间: {execution_time} 秒")
